Frontend WebRTC Simulcast-Konfiguration: Multi-Stream-Qualitätsmanagement für globale Anwendungen

In der heutigen vernetzten Welt ist Echtzeitkommunikation (RTC) für Unternehmen und Einzelpersonen gleichermaßen unerlässlich geworden. WebRTC (Web Real-Time Communication) hat sich als leistungsstarke Technologie etabliert, die nahtlose Audio- und Videokommunikation direkt in Webbrowsern und mobilen Anwendungen ermöglicht. Die Bereitstellung eines konsistenten und qualitativ hochwertigen Videoerlebnisses für ein globales Publikum stellt jedoch aufgrund unterschiedlicher Netzwerkbedingungen, Gerätefähigkeiten und Bandbreitenbeschränkungen der Benutzer erhebliche Herausforderungen dar. Hier kommt Simulcast ins Spiel.

Was ist WebRTC Simulcast?

Simulcast ist eine Technik, die in WebRTC verwendet wird, um mehrere Versionen desselben Videostreams, jede mit unterschiedlichen Auflösungen und Bitraten, gleichzeitig zu kodieren und zu übertragen. Dies ermöglicht es der Empfängerseite (z. B. einem Videokonferenzserver oder einem anderen Peer), dynamisch den am besten geeigneten Stream basierend auf ihren Netzwerkbedingungen und Verarbeitungsfähigkeiten auszuwählen. Dies verbessert das Benutzererlebnis erheblich, indem die Videoqualität an die verfügbare Bandbreite angepasst und Videofreezes oder -unterbrechungen verhindert werden.

Stellen Sie sich ein globales Team vor, das über Videokonferenz an einem Projekt zusammenarbeitet. Ein Teilnehmer könnte in Tokio über eine Hochgeschwindigkeits-Glasfaserverbindung verfügen, während ein anderer ein Mobilgerät in einem 4G-Netzwerk im ländlichen Argentinien verwendet. Ohne Simulcast müsste der Server eine einzige Qualitätsstufe auswählen, was möglicherweise den Benutzer mit der schnellen Verbindung benachteiligen oder die Besprechung für den Benutzer mit begrenzter Bandbreite unmöglich machen würde. Simulcast stellt sicher, dass jeder mit dem bestmöglichen Erlebnis teilnehmen kann, basierend auf seinen individuellen Einschränkungen.

Warum Simulcast verwenden?

Simulcast bietet mehrere entscheidende Vorteile:

• Adaptives Bitraten-Streaming: Ermöglicht die dynamische Anpassung der Videoqualität basierend auf den Netzwerkbedingungen. Wenn die Bandbreite sinkt, kann der Empfänger zu einem Stream mit niedrigerer Auflösung wechseln, um ein flüssiges, ununterbrochenes Erlebnis zu gewährleisten. Umgekehrt, wenn die Bandbreite zunimmt, kann der Empfänger zu einem Stream mit höherer Auflösung wechseln, um eine bessere visuelle Qualität zu erzielen.
• Verbesserte Benutzererfahrung: Reduziert die Wahrscheinlichkeit von Videofreezes, Rucklern und Pufferungen, was zu einem angenehmeren und produktiveren Kommunikationserlebnis führt.
• Skalierbarkeit: Besonders nützlich bei großen Gruppen-Videokonferenzen oder Webinaren. Anstatt den Sender zu zwingen, eine einzige Qualitätsstufe zu wählen, die dem kleinsten gemeinsamen Nenner entspricht, kann der Server den Stream für jeden einzelnen Teilnehmer anpassen.
• Gerätekompatibilität: Unterstützt eine größere Bandbreite von Geräten mit unterschiedlicher Rechenleistung und Bildschirmgrößen. Geräte mit geringerer Leistung können Streams mit niedrigerer Auflösung auswählen, während leistungsfähigere Geräte Streams mit höherer Auflösung genießen können. Dies gewährleistet ein konsistentes Erlebnis über eine Vielzahl von Hardware hinweg.
• Reduzierte Serverlast: In vielen Fällen reduziert die Verwendung von Simulcast mit einer Selective Forwarding Unit (SFU) die Verarbeitungslast auf dem Server im Vergleich zum Transcoding. Die SFU leitet einfach den entsprechenden Stream an jeden Client weiter, ohne das Video dekodieren und neu kodieren zu müssen.

Frontend Simulcast-Konfiguration: Eine Schritt-für-Schritt-Anleitung

Die Konfiguration von Simulcast im Frontend umfasst mehrere Schritte, darunter:

1. Einrichten der WebRTC PeerConnection: Die Grundlage jeder WebRTC-Anwendung ist das RTCPeerConnection-Objekt.
2. Erstellen eines Transceivers mit Simulcast-Parametern: Konfigurieren Sie den Transceiver so, dass er mehrere Streams mit unterschiedlichen Qualitäten sendet.
3. Umgang mit dem SDP (Session Description Protocol): Das SDP beschreibt die Medienfähigkeiten jedes Peers. Die Simulcast-Konfiguration erfordert die Modifikation des SDP, um die Verfügbarkeit mehrerer Streams anzuzeigen.
4. Verwalten der Stream-Auswahl: Der Empfänger muss in der Lage sein, den geeigneten Stream basierend auf Netzwerkbedingungen und Gerätefähigkeiten auszuwählen.

Schritt 1: Einrichten der WebRTC PeerConnection

Zuerst müssen Sie eine RTCPeerConnection einrichten. Dieses Objekt erleichtert die Kommunikation zwischen zwei Peers.

            // Create a new PeerConnection
const peerConnection = new RTCPeerConnection(configuration);

// 'configuration' is an optional object containing STUN/TURN server information.
const configuration = {
  iceServers: [
    { urls: 'stun:stun.l.google.com:19302' },
    { urls: 'stun:stun1.l.google.com:19302' }
  ]
};

            

              
                Copy
              
            
          

Schritt 2: Erstellen eines Transceivers mit Simulcast-Parametern

Die Methode addTransceiver wird verwendet, um einen Medienstrom (Audio oder Video) zur PeerConnection hinzuzufügen. Um Simulcast zu aktivieren, müssen Sie den Parameter sendEncodings mit einem Array von Kodierungskonfigurationen angeben.

            // Assuming you have a video track
const videoTrack = localStream.getVideoTracks()[0];

// Configure Simulcast encodings
const encodings = [
  {
    rid: 'high',
    maxBitrate: 1500000, // 1.5 Mbps
    scaleResolutionDownBy: 1.0 // Original resolution
  },
  {
    rid: 'mid',
    maxBitrate: 750000,  // 750 Kbps
    scaleResolutionDownBy: 2.0 // Half resolution
  },
  {
    rid: 'low',
    maxBitrate: 300000,  // 300 Kbps
    scaleResolutionDownBy: 4.0 // Quarter resolution
  }
];

// Add the transceiver with Simulcast configuration
const transceiver = peerConnection.addTransceiver(videoTrack, { sendEncodings: encodings });

            

              
                Copy
              
            
          

Erläuterung:

• rid: Eine eindeutige Kennung für jede Kodierung. Dies wird später für die Stream-Auswahl verwendet.
• maxBitrate: Die maximale Bitrate für die Kodierung (in Bits pro Sekunde).
• scaleResolutionDownBy: Ein Faktor zum Herunterskalieren der Videoauflösung. Ein Wert von 2.0 bedeutet die Hälfte der ursprünglichen Breite und Höhe.

Diese Konfiguration definiert drei Simulcast-Streams: einen hochwertigen Stream mit der Originalauflösung und einer maximalen Bitrate von 1,5 Mbit/s, einen Stream mittlerer Qualität mit der halben Auflösung und einer maximalen Bitrate von 750 Kbit/s sowie einen Stream niedriger Qualität mit einem Viertel der Auflösung und einer maximalen Bitrate von 300 Kbit/s.

Schritt 3: Umgang mit dem SDP (Session Description Protocol)

Das SDP beschreibt die Medienfähigkeiten jedes Peers. Nach dem Hinzufügen des Transceivers müssen Sie ein Angebot (vom Sender) oder eine Antwort (vom Empfänger) erstellen und diese mit dem anderen Peer austauschen. Das SDP muss geändert werden, um die Simulcast-Konfiguration widerzuspiegeln. Obwohl moderne Browser die SDP-Aushandlung für Simulcast größtenteils automatisch handhaben, hilft das Verständnis des Prozesses bei der Behebung potenzieller Probleme.

            // Create an offer (sender)
peerConnection.createOffer().then(offer => {
  // Set the local description
  peerConnection.setLocalDescription(offer);

  // Send the offer to the remote peer (via signaling server)
  sendOfferToRemotePeer(offer);
});

// Receive an offer (receiver)
function handleOffer(offer) {
  peerConnection.setRemoteDescription(offer).then(() => {
    // Create an answer
    return peerConnection.createAnswer();
  }).then(answer => {
    // Set the local description
    peerConnection.setLocalDescription(answer);

    // Send the answer to the remote peer (via signaling server)
    sendAnswerToRemotePeer(answer);
  });
}

// Receive an answer (sender)
function handleAnswer(answer) {
  peerConnection.setRemoteDescription(answer);
}

            

              
                Copy
              
            
          

Der Signalisierungsserver ist für den Austausch von SDP-Angeboten und -Antworten zwischen den Peers verantwortlich. Dies wird typischerweise mittels WebSockets oder eines anderen Echtzeit-Kommunikationsprotokolls implementiert.

Wichtiger Hinweis: Obwohl der Browser die SDP-Manipulation für Simulcast im Allgemeinen selbst übernimmt, kann die Überprüfung des generierten SDP für die Fehlersuche und das Verständnis der Konfiguration hilfreich sein. Sie können Tools wie chrome://webrtc-internals verwenden, um das SDP zu untersuchen.

Schritt 4: Verwalten der Stream-Auswahl

Auf der Empfängerseite müssen Sie in der Lage sein, den geeigneten Stream basierend auf den Netzwerkbedingungen auszuwählen. Dies geschieht typischerweise mit dem Objekt RTCRtpReceiver und dessen Methode getSynchronizationSources().

            peerConnection.ontrack = (event) => {
  const receiver = event.receiver;

  // Get the synchronization sources (SSRCs)
  const ssrcs = receiver.getSynchronizationSources();

  // Assuming you have access to the transceiver object (from addTransceiver)
  const transceiver = event.transceiver; // Get transceiver from the 'track' event.

  // Find the encoding based on SSRC
  let selectedEncoding = null;
  for (const encoding of transceiver.sender.getEncodings()) {
     //Encoding IDs are not reliable in some situations. Check other features here instead. This is a placeholder
     selectedEncoding = encoding; 
     break;
  }
  // Example: Check network conditions and switch streams
  if (networkIsCongested()) {
    // Reduce stream quality.
     transceiver.direction = "recvonly";
    // You might need to renegotiate the connection or use a different approach depending on your signaling and server implementation
  } else {
     transceiver.direction = "sendrecv";
  }

  //Attach the track to the video element
  videoElement.srcObject = event.streams[0];
};

            

              
                Copy
              
            
          

Erläuterung:

• Das ontrack-Ereignis wird ausgelöst, wenn ein neuer Medientrack empfangen wird.
• Die Methode getSynchronizationSources() gibt ein Array von Synchronisationsquellen (SSRCS) zurück, die mit dem Track verbunden sind. Jede SSRC entspricht einem anderen Simulcast-Stream.
• Sie können dann die Netzwerkbedingungen analysieren (z. B. unter Verwendung einer Bandbreitenschätzungsbibliothek) und den geeigneten Stream auswählen, indem Sie die preferredEncodingId im RTCRtpTransceiver festlegen.

Alternativer Ansatz (mit RTCRtpEncodingParameters.active):

Anstatt die Transceiver-Richtung direkt zu ändern, können Sie versuchen, Kodierungen selektiv zu aktivieren oder zu deaktivieren, indem Sie die active-Eigenschaft von RTCRtpEncodingParameters manipulieren. Dies ist oft ein saubererer Ansatz.

            peerConnection.ontrack = (event) => {
      const receiver = event.receiver;
      const transceiver = event.transceiver;

      // Define a function to update encodings based on network conditions.
      function updateEncodings(isCongested) {
        const sendEncodings = transceiver.sender.getEncodings();

        if (sendEncodings && sendEncodings.length > 0) {
          if (isCongested) {
            // Activate only the low-quality encoding
            sendEncodings.forEach((encoding, index) => {
              encoding.active = (index === 2); // Assuming 'low' is the third encoding (index 2)
            });
          } else {
            // Activate all encodings
            sendEncodings.forEach(encoding => {
              encoding.active = true;
            });
          }

          // Apply the updated encodings (This is a simplified example)
          // In a real application, you might need to re-negotiate the PeerConnection
          // or use a media server to apply these changes.
          // Here's a placeholder to show the concept:
          console.log("Updated encodings:", sendEncodings);
          // In reality, setting active=false doesn't stop sending. So, this requires more handling!

        }
      }

      // Example: Check network conditions and switch streams
      if (networkIsCongested()) {
        updateEncodings(true);
      } else {
        updateEncodings(false);
      }

      videoElement.srcObject = event.streams[0];
    };

            

              
                Copy
              
            
          

Wichtige Überlegungen:

• Erkennung von Netzwerküberlastung: Sie müssen einen Mechanismus zur Erkennung von Netzwerküberlastung implementieren. Dies könnte die Verwendung der WebRTC-Statistik-API (getStats()) umfassen, um Paketverlust, Round-Trip-Time (RTT) und verfügbare Bandbreite zu überwachen. Speziell für die Bandbreitenschätzung entwickelte Bibliotheken können ebenfalls hilfreich sein.
• Signalisierung: Je nach Struktur Ihrer Anwendung müssen Sie möglicherweise die Änderungen der Stream-Auswahl an den anderen Peer signalisieren. In SFU-Szenarien übernimmt die SFU typischerweise die Stream-Auswahl. In Peer-to-Peer-Szenarien müssen Sie möglicherweise die PeerConnection neu verhandeln.
• SFU-Unterstützung: Bei Verwendung einer SFU (Selective Forwarding Unit) übernimmt die SFU typischerweise den Stream-Auswahlprozess. Die Frontend-Anwendung muss Simulcast weiterhin konfigurieren, aber die SFU wechselt dynamisch zwischen den Streams basierend auf den Netzwerkbedingungen jedes Teilnehmers. Beliebte SFUs sind Janus, Jitsi Meet und Mediasoup.

Beispiel: Eine vereinfachte Simulcast-Implementierung

Hier ist ein vereinfachtes Beispiel, das die Kernkonzepte der Simulcast-Konfiguration demonstriert:

            // HTML (simplified)
<video id="localVideo" autoplay muted></video>
<video id="remoteVideo" autoplay></video>
<button id="startCall">Start Call</button>

// JavaScript (simplified)
const localVideo = document.getElementById('localVideo');
const remoteVideo = document.getElementById('remoteVideo');
const startCallButton = document.getElementById('startCall');

let peerConnection;
let localStream;

async function startCall() {
  startCallButton.disabled = true;

  try {
    localStream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
    localVideo.srcObject = localStream;

    // Configuration (STUN servers)
    const configuration = {
      iceServers: [
        { urls: 'stun:stun.l.google.com:19302' },
        { urls: 'stun:stun1.l.google.com:19302' }
      ]
    };

    peerConnection = new RTCPeerConnection(configuration);

    // Configure Simulcast encodings
    const encodings = [
      { rid: 'high', maxBitrate: 1500000, scaleResolutionDownBy: 1.0 },
      { rid: 'mid', maxBitrate: 750000, scaleResolutionDownBy: 2.0 },
      { rid: 'low', maxBitrate: 300000, scaleResolutionDownBy: 4.0 }
    ];

    // Add video transceiver
    const videoTransceiver = peerConnection.addTransceiver(localStream.getVideoTracks()[0], { sendEncodings: encodings, direction: 'sendrecv' });

    // Add audio transceiver
    const audioTransceiver = peerConnection.addTransceiver(localStream.getAudioTracks()[0], { direction: 'sendrecv' });


    peerConnection.ontrack = (event) => {
      remoteVideo.srcObject = event.streams[0];
    };

    // Handle ICE candidates
    peerConnection.onicecandidate = (event) => {
      if (event.candidate) {
        // Send ICE candidate to remote peer (via signaling server)
        sendIceCandidateToRemotePeer(event.candidate);
      }
    };

    // Create and send offer (if initiator)
    const offer = await peerConnection.createOffer();
    await peerConnection.setLocalDescription(offer);
    sendOfferToRemotePeer(offer);

  } catch (error) {
    console.error('Error starting call:', error);
  }
}

startCallButton.addEventListener('click', startCall);

// Placeholder functions for signaling
function sendOfferToRemotePeer(offer) {
  console.log('Sending offer:', offer);
  // In a real application, you would use a signaling server to send the offer
}

function sendIceCandidateToRemotePeer(candidate) {
  console.log('Sending ICE candidate:', candidate);
  // In a real application, you would use a signaling server to send the ICE candidate
}

            

              
                Copy
              
            
          

Wichtig: Dies ist ein stark vereinfachtes Beispiel und lässt wesentliche Aspekte einer realen WebRTC-Anwendung aus, wie Signalisierung, Fehlerbehandlung und Überwachung der Netzwerkbedingungen. Dieser Code ist ein guter Ausgangspunkt, um die Grundlagen der Implementierung von Simulcast im Frontend zu verstehen, erfordert jedoch erhebliche Ergänzungen, um produktionsreif zu sein.

WebRTC Statistik-API (getStats())

Die WebRTC Statistik-API liefert wertvolle Informationen über den Zustand der Verbindung, einschließlich Paketverlust, RTT und verfügbarer Bandbreite. Sie können diese Informationen nutzen, um die Simulcast-Stream-Auswahl dynamisch anzupassen. Der Zugriff auf Statistiken ist entscheidend, um die gesendeten oder empfangenen Qualitäten dynamisch anzupassen. Hier ist eine grundlegende Demonstration:

            async function getAndProcessStats() {
  if (!peerConnection) return;

  const stats = await peerConnection.getStats();
  stats.forEach(report => {
    if (report.type === 'inbound-rtp') {
      // Statistics about received media
      console.log('Inbound RTP Report:', report);

      // Example: Check packet loss
      if (report.packetsLost && report.packetsReceived) {
        const packetLossRatio = report.packetsLost / report.packetsReceived;
        console.log('Packet Loss Ratio:', packetLossRatio);
        // Use packetLossRatio to adapt stream selection
      }
    } else if (report.type === 'outbound-rtp') {
      // Statistics about sent media
      console.log('Outbound RTP Report:', report);
    } else if (report.type === 'candidate-pair' && report.state === 'succeeded') {
        console.log("Selected Candidate Pair Report: ", report);
        //report.availableOutgoingBitrate
    }
  });
}

// Call this function periodically (e.g., every 1 second)
setInterval(getAndProcessStats, 1000);

            

              
                Copy
              
            
          

Herausforderungen und Überlegungen

Obwohl Simulcast erhebliche Vorteile bietet, bringt es auch einige Herausforderungen mit sich:

• Erhöhter Bandbreitenverbrauch: Simulcast erfordert die gleichzeitige Übertragung mehrerer Streams, was den Bandbreitenverbrauch auf der Sendeseite erhöht. Eine sorgfältige Konfiguration von Bitrate und Auflösung für jeden Stream ist entscheidend, um die Bandbreitennutzung zu optimieren.
• Komplexität: Die Implementierung von Simulcast erfordert eine komplexere Frontend-Logik im Vergleich zu Single-Stream-Implementierungen.
• Browser-Unterstützung: Obwohl Simulcast in modernen Browsern weitgehend unterstützt wird, ist es wichtig, Ihre Implementierung über verschiedene Browser und Geräte hinweg zu testen, um die Kompatibilität sicherzustellen. Überprüfen Sie die browserspezifische Dokumentation und Updates auf potenzielle Probleme.
• Signalisierungs-Overhead: Das Signalisieren der Verfügbarkeit mehrerer Streams und die Handhabung von Änderungen bei der Stream-Auswahl können den Signalisierungsprozess komplexer machen.
• CPU-Auslastung: Das Kodieren mehrerer Streams kann die CPU-Auslastung auf dem sendenden Gerät erhöhen, insbesondere auf Geräten mit geringer Leistung. Die Optimierung der Kodierungsparameter und die Verwendung von Hardwarebeschleunigung können helfen, dieses Problem zu mindern.
• Medienserver-Überlegungen: Die Integration von Simulcast in Medienserver erfordert ein Verständnis dafür, wie der Server mehrere Streams handhabt und wie Änderungen bei der Stream-Auswahl signalisiert werden.

Best Practices für die Simulcast-Konfiguration

Hier sind einige Best Practices für die Konfiguration von Simulcast:

• Beginnen Sie mit gängigen Auflösungen: Bieten Sie zunächst die gängigsten Auflösungen an (z. B. 1080p, 720p, 360p).
• Bitraten optimieren: Wählen Sie die Bitraten für jeden Stream sorgfältig aus, um Qualität und Bandbreitenverbrauch in Einklang zu bringen. Ziehen Sie die Verwendung variabler Bitraten (VBR) in Betracht, um sich an wechselnde Netzwerkbedingungen anzupassen.
• Hardwarebeschleunigung nutzen: Nutzen Sie die Hardwarebeschleunigung (falls verfügbar), um die CPU-Auslastung während der Kodierung zu reduzieren.
• Gründlich testen: Testen Sie Ihre Implementierung über verschiedene Browser, Geräte und Netzwerkbedingungen hinweg.
• Leistung überwachen: Verwenden Sie die WebRTC-Statistik-API, um die Leistung zu überwachen und potenzielle Probleme zu identifizieren.
• Benutzererfahrung priorisieren: Konzentrieren Sie sich darauf, ein flüssiges und ununterbrochenes Videoerlebnis zu bieten, auch bei niedrigeren Auflösungen.
• Graceful Degradation: Wenn die Bandbreite stark eingeschränkt ist, implementieren Sie eine Strategie zur „Graceful Degradation“, z. B. das Stummschalten des Videos oder den Wechsel in den Nur-Audio-Modus.
• SVC in Betracht ziehen: Scalable Video Coding (SVC) ist eine Alternative zu Simulcast, die in einigen Szenarien eine bessere Bandbreitennutzung bieten kann.

Globale Überlegungen für WebRTC Simulcast

Beim globalen Einsatz von WebRTC-Anwendungen mit Simulcast sollten Sie Folgendes beachten:

• Netzwerkinfrastruktur: Berücksichtigen Sie die unterschiedliche Netzwerkinfrastruktur in verschiedenen Regionen. Einige Regionen können begrenzte Bandbreite oder hohe Latenz aufweisen.
• Gerätevielfalt: Unterstützen Sie eine Vielzahl von Geräten mit unterschiedlicher Rechenleistung und Bildschirmgrößen.
• Lokalisierung: Lokalisieren Sie Ihre Anwendung, um verschiedene Sprachen und kulturelle Konventionen zu unterstützen.
• Einhaltung gesetzlicher Vorschriften: Beachten Sie alle regulatorischen Anforderungen bezüglich Datenschutz und Sicherheit in verschiedenen Ländern.
• Content Delivery Networks (CDNs): Obwohl WebRTC primär P2P- oder SFU-basiert ist, können CDNs verwendet werden, um statische Assets zu verteilen und möglicherweise bei der Signalisierung zu unterstützen.

Fazit

WebRTC Simulcast ist eine leistungsstarke Technik zur Bereitstellung hochwertiger Videoerlebnisse für ein globales Publikum. Durch die Kodierung und Übertragung mehrerer Streams mit unterschiedlichen Qualitäten ermöglicht Simulcast dem Empfänger, sich dynamisch an wechselnde Netzwerkbedingungen und Gerätefähigkeiten anzupassen. Obwohl die Implementierung von Simulcast eine sorgfältige Konfiguration und Tests erfordert, sind die Vorteile hinsichtlich verbesserter Benutzererfahrung und Skalierbarkeit erheblich. Indem Sie die in diesem Leitfaden beschriebenen Best Practices befolgen, können Sie Simulcast nutzen, um robuste und anpassungsfähige WebRTC-Anwendungen zu erstellen, die den Anforderungen der heutigen vernetzten Welt gerecht werden.

Durch das Verständnis der Kernkonzepte und die Befolgung der in diesem Leitfaden beschriebenen Schritte können Entwickler Simulcast effektiv in ihren WebRTC-Anwendungen implementieren und so einem globalen Publikum ein überragendes Benutzererlebnis bieten, unabhängig von ihren Netzwerkbedingungen oder Gerätefähigkeiten. Simulcast ist ein entscheidendes Werkzeug für den Aufbau robuster und skalierbarer Echtzeit-Kommunikationslösungen in der heutigen vielfältigen digitalen Landschaft. Es ist jedoch wichtig, sich daran zu erinnern, dass es nur ein Werkzeug in einer Reihe von Technologien ist und neue Verbesserungen, wie SVC, schnell iteriert werden, um noch effizientere Systeme zu schaffen.